Remotely discover and map a network resource model in a cloud environment

ABSTRACT

Systems and methods are provided for implementing a new discovery and mapping micro-service. The discovery and mapping micro-service may be implemented to dynamically discover and map a cloud environment as the deployed resources change. The new micro-service can map the environment without prior knowledge (e.g., without a template or manual interaction) by initializing itself and tracking resource changes. Once a new message is received in relation to a resource change, the disclosed system may realign and/or update the map of the cloud environment.

BACKGROUND

A service-oriented architecture (SOA) or service-based architecture (SBA) of a computing environment can implement a software application as a collection of services. As the label implies, the SOA or SBA emphasizes services as the primary architecture component used to implement and execute functions. For example, a set of remote servers or virtual machines will execute machine readable instructions to implement one or more services and provide output to the computing device that requested a response through an application programming interface (API).

In a micro-services architecture, where components of the SOA are partitioned into smaller and more manageable tasks, each of the micro-services can be implemented independently on multiple machines that are readily available. In some computing environments, the micro-services are assigned to machines at will, resulting in a loose coupling between the machines that are implementing a small portion of the overall service and the originating application.

Loose coupling reduces dependencies on particular machines and the service developers do not need to track the users of the service. Rather, the users of the service can generally access the API to initiate the application request and start a chain of service calls that implement various network functions.

BRIEF DESCRIPTION OF THE DRAWINGS

The present disclosure, in accordance with one or more various embodiments, is described in detail with reference to the following figures. The figures are provided for purposes of illustration only and merely depict typical or example embodiments.

FIG. 1 illustrates a cloud environment and computing device to implement micro-services, in accordance with embodiments of the application.

FIG. 2 illustrates a process for dynamically discovering and mapping the cloud environment, in accordance with embodiments of the application

FIG. 3 is an illustrative mapping of micro-services in the cloud environment, in accordance with embodiments of the application.

FIG. 4 is an example computing component that may be used to implement various features of embodiments described in the present disclosure.

FIG. 5 depicts a block diagram of an example computer system in which various of the embodiments described herein may be implemented.

The figures are not exhaustive and do not limit the present disclosure to the precise form disclosed.

DETAILED DESCRIPTION

In an SOA or SBA, a set of interconnected network functions (NFs) deliver the control plane functionality and common data repositories of a 5G network. To enable portability and consistency, the functionality of the system is defined by one or more standards, including for example, the 3rd Generation Partnership Project (3GPP) and can be applied within the 5G core like network slicing, control user plane separation, and edge computing across various industries.

With benefits of the SOA or SBA, tracking the micro-service implementations corresponding with the originating application is often difficult, especially since the machines that implement each of the components of the service (e.g., the network functions) can be scattered across the computing environment. As such, once micro-services are deployed in a cloud environment, it is difficult to correlate the application components that are deployed as resources (e.g., Kubernetes deployments, pods, services, volumes, etc.) to the originating application. The difficulty may arise from, for example, the cloud environment being a shared cloud that hosts many entities that can each correspond with one or more distributed systems that are not otherwise in communication with each other, implement different communication protocols, and/or operate behind multiple layers of security. Each of the entities may request or implement functionality corresponding with a plurality of network functions (NFs). As such, identifying where processes are deployed or originate can be managed in a mapping of the cloud environment.

Various components of the cloud environment and service request system may frustrate a seemingly simple task of mapping the cloud environment. For example, the cloud environment may be an open source (OS) container orchestration platform that automates many of the manual processes involved in deploying, managing, and scaling containerized applications. The container orchestration platform may manage containerized workloads and services automatically, which can facilitate both declarative configuration and automation for implementation of the application. However, since the container orchestration platform may be a large, rapidly growing ecosystem, frequent computing changes can occur with load balancing or other automated processes within the cloud environment (e.g., as reallocation of workload and computing resources).

Embodiments of the application describe a computing device to implement a new micro-service or discovery and mapping micro-service (used interchangeably) in addition to the micro-services implemented with the originating application. For example, the discovery and mapping micro-service may be executed in addition to one or more micro-services implemented to perform network functions that are separated into application components. The discovery and mapping micro-service may be implemented using a discovery engine to dynamically discover and map the cloud environment. For example, while the originating application may be split into micro-service components that are deployed as resources in a cloud environment, the discovery and mapping micro-service can map the cloud environment and existing micro-services as they change. The discovery and mapping micro-service can map the environment without prior knowledge (e.g., without a template or manual interaction) by initializing itself and tracking any resource changes. In some examples, the tracking may rely on “hooks” and messaging that is locally implemented in the cloud environment. Once a new message is received in relation to a resource change, the disclosed system may automatically realign and/or update the map of the cloud environment.

For example, when a network function (NF) is deployed in the cloud environment, it may create a set of decomposed cloud resources (e.g., cloud environment native objects or Kubernetes® native objects) including one or more pods, deployment functions, or services for its runtime execution and management. Subsequently, the cloud environment can provide a view of the deployed NFs based on a decomposed cloud native resource model. This can be queried using APIs and/or command line kubectl tool provided by the cloud environment.

Technical improvements are realized throughout the disclosure. For example, by discovering NFs and mapping the cloud environment from an external source, the system can rely on the discovery/mapping to take actions to improve processing in the external system. This may include identifying portions of an executed process in the cloud environment that may be delaying the overall operability of a function and assign priority for resolving the issue. In another example, secondary machine readable instructions may be executed to initiate an automatic resolution of issues (e.g., rerouting traffic, requesting execution of a new NF, etc.). The impacted service can be adjusted, for example, to acquire additional resources or processing capability to reduce the impact to the service or environment.

FIG. 1 illustrates a cloud environment and computing device to implement micro-services, in accordance with embodiments of the application. In this illustration, master cloud environment 102 comprises scheduler 104, controllers 106, ETCD server 108 (e.g., “etcd” corresponds with a concatenation of the “/etc” folder in UNIX that stores one or more system configuration files for a single system and “d” stands for “distributed”), and application programming interface (API) server 120 that accesses computing device 110 and one or more nodes 122 (illustrated as first node 122A, second node 1228, third node 122C, and fourth node 122D).

In the illustrated example, scheduler 104 is a default scheduler that runs as part of the control plane. For example, scheduler 104 may determine which nodes 122 can receive a placement of one or more pods 124 in a scheduling queue (e.g., according to constraints and available resources). Scheduler 104 may also rank each node 122 and bind the pod 124 to the node 122. Scheduler 104 may also be designed to allow computing device 110 to provide a new scheduling component and use the new scheduling component instead of the default configuration of nodes and pods.

Controllers 106 are another component in the cluster architecture with scheduler 104 (e.g., in the control plane) that include rules in the form of computer readable instructions. In some examples, controllers 106 may enforce the rules by monitoring the state of various clusters and then making or requesting changes to the scheduling of resources (e.g., allocating blocks of IP addresses for a group of pods 124, integrating services like load balancers, network packet filtering, or target health checking) when the computing environment exceeds a threshold or otherwise triggers one of the stored rules. Each controller 106 may be configured to move the current cluster state closer to the desired state. In some examples, the controller 106 might execute an action itself (e.g., load balancing, allocating IP addresses, or other actions described herein) or may transmit instructions to a component to execute the action. For example, controller 106 may send a message to API server 120. API server 120 may create or remove pods 124 (illustrated as first pod 124A, second pod 124B, third pod 124C, and fourth pod 124D). The pods 124 may schedule and run tasks while other components in the control plane may act on the new information (e.g., when new IP addresses are allocated, the pods 124 may utilize the new IP addresses to transmit or receive data associated with the tasks).

ETCD server 108 comprises a key value data store that may include a plurality of cluster data (e.g., API data, configuration data, or other inventory data). ETCD server 108 may store data that represents a snapshot of the overall state of one or more clusters at any given point of time.

Computing device 110 is a device that interacts with the master cloud environment 102 to help dynamically discover and map the cloud environment. In some examples, computing device 110 may perform actions to implement a discovery and mapping micro-service in addition to the micro-services implemented with the original application, including discovery engine 112 to identify one or more existing micro-services and components involved in executing a network function and modeling engine 114 to generate, align, and update a map of the cloud environment based on the identified, existing micro-services and components. In some examples, discovery engine 112 and modeling engine 114 are implemented as a single micro-service (e.g., discovery and mapping micro-service) that is performing both discovery and mapping. In some examples, discovery engine 112 and modeling engine 114 are implemented as separate micro-services, engines, modules, or other components of computing device 110.

In some examples, one or more computing devices 110 may request execution of an original application. Master cloud environment 102 may receive the request via API server 120 and activate one or more network functions to execute the request.

API server 120 may receive requests (e.g., queries) from computing device 110 and manipulate the state of API objects in the cloud environment, including pods 124 or other components like Namespaces, ConfigMaps, or Events. In some examples, API server 120 processes and validates REST requests and updates the state of the API objects in ETCD server 108, which may enable computing device 110 to configure workloads and containers across the nodes 122.

API server 120 may call the watch function associated with the API to monitor one or more clusters, implement configuration changes, or restore any divergences of the state of the cluster back to its declared state. As an example, computing device 110 may specify that three instances of a particular pod 124 are scheduled to be running. ETCD server 108 stores this fact. If it is found that less than three instances are running, the difference between two instances and three instances can be automatically detected and controllers 106 or scheduler 104 can schedule the creation of an additional instance of that pod 124.

Nodes 122 (illustrated as first node 122A, second node 122B, third node 122C, and fourth node 122D) are virtual or physical machines, depending on the cluster, that can run a workload task. One or more containers 126 may be placed into pods 124 that run on nodes 122. Each node 122 may run one or more pods 124. Each node 122 may be managed by the control plane and contain the services necessary to run pods 124.

Nodes 122 may comprise kubelets 130 (illustrated as first kubelets 130A, second kubelets 1308, third kubelets 130C, and fourth kubelets 130D), depending on the specific implementation in the cloud environment. The kubelet 130 may correspond with a node agent that runs on each node to register the node 122 with API server 120 using one of: the hostname; a flag to override the hostname; or specific logic for a cloud provider.

In some examples, nodes 122 may self-register with API server 120 using a flag or other data object, using kubelet 130. As an illustrative example, when the flag “register-node” is true, the kubelet 130 of the node 122 can attempt to register itself with API server 120.

In some examples, nodes 122 may comprise kube-proxies (illustrated as first kube-proxy 132A, second kube-proxy 1328, third kube-proxy 132C, and fourth kube-proxy 132D), in addition to or instead of kubelet 130, depending on the specific implementation in the cloud environment. The kube-proxy 132 may comprise a routing layer on each node 122 that may route network traffic between clusters. The kube-proxy 132 can manage services defined on each node 122 and can forward one or more messages using various protocols, including Transmission Control Protocol (TCP), User Datagram Protocol (UDP), and Stream Control Transmission Protocol (SCTP), or may implement round robin TCP, UDP, and SCTP forwarding across a set of backend devices.

Pods 124 (illustrated as first pod 124A, second pod 1248, third pod 124C, fourth pod 124D, and fifth pod 124E) are the smallest deployable units of computing that computing device 110 may create and manage in the cloud environment. For example, a pod 124 is a group of one or more containers 126, with shared storage/network resources, and a specification for how to run the containers 126.

Containers 126 (illustrated as first container 126A, second container 1268, third container 126C, fourth container 126D, and fifth container 126E) are configured to generate, integrate, and execute applications. Containers 126 may have its own filesystem, share of central processing unit (CPU) or graphics processing unit (GPU), memory, or process space. As containers 126 may be decoupled from the underlying infrastructure, containers 126 may be portable across clouds and OS distributions and may be restarted or replaced at will by controller 106 or other components of master cloud environment 102.

FIG. 2 illustrates a process for dynamically discovering and mapping the cloud environment by computing device 110, in accordance with embodiments of the application. The cloud environment may correspond with master cloud environment 102 illustrated in FIG. 1 and the discovering and mapping actions may be performed by computing device 110 illustrated in FIG. 1 .

At block 1, computing device 110 may access a command line tool for interacting with ETCD server 108 as illustrated in FIG. 1 . ETCD server 108 may store/persist one or more cloud resources provided by master cloud environment 102, including rules or parameters corresponding with a network topology mapping function (e.g., TopologyMapper), Authentication Server Function (AUSF), and the unified data management (UDM) function.

In some examples, computing device 110 may authenticate the device with master cloud environment 102 as illustrated in block 1A. As an illustrative example, master cloud environment 102 may receive authentication credentials to authenticate computing device 110. The AUSF may store one or more authentication keys related to the authentication (e.g., with ETCD server 108) at block 1B to persist the cloud data.

In some examples, computing device 110 may submit an Access and Mobility Management Function (AMF) as illustrated in block 1C. The AMF can help manage the computing device 110 registration and authentication via AUSF and identification via a unified data management (UDM) function. The UDM can manage data for access authorization, user registration, and data network profiles. For example, the authentication request provided by computing device 110 may comprise subscriber data to the session management function (SMF), which can allocate an IP address and manage user sessions on the network. In other words, the UDM can help store subscriber data and profiles, while also generating an authentication vector as part of the authentication process.

At block 2, computing device 110 may implement a dynamic discovery of the cloud environment, including master cloud environment 102, using discovery engine 112. For example, computing device 110 and master cloud environment 102 may participate in an authentication process (e.g., using password/username credentials associated with computing device 110, which may be a different authentication process than executed with the AUSF). The second authentication process may allow computing device 110 to access the cloud environment.

Once authenticated with master cloud environment 102, computing device 110 may transmit a request to initiate a discovery and mapping micro-service using a rule-based discovery engine. In response, master cloud environment 102 may generate the discovery and mapping micro-service that can initialize itself by querying cloud resources and NRM custom resources, as described herein, and applying predefined or stored rules associated with the discovery and mapping micro-service.

In some examples, computing device 110 may receive a list of resources through various methods at block 2A. One illustrative example is to access ETCD 108 (e.g., via API server 120) to identify one or more resources implemented in master cloud environment 102 through discovery engine 112. For example, computing device 110 may access a command line tool for interacting with ETCD server 108 (e.g., “etcdctl” command), including reading a key value, watching for key changes (e.g., “watch” command), or reading a past version of the key.

In some examples, computing device 110 may create a user-defined custom resource (CRD) to help model workloads as resources (e.g., objects/kind) of master cloud environment 102. As an illustrated example, discovery engine 112 may perform a discovery process of NFs (e.g., using predefined rules) and the CRD may represent the discovered NFs as a cloud-native resource.

At block 2B, computing device 110 may evaluate the list of resources received from master cloud environment 102. For example, the discovery process may identify NFs according to stored rules, including both stateful and stateless NFs, or by identifying 5G NFs having attributes that are aligned with one or more standards, including for example, the 3GPP NRM model. In some examples, this discovery process may identify any NFs implemented by master cloud environment 102, that are stateful. Computing device 110 may identify and filter (e.g., remove) NFs that are stateless from the list of identified network functions in the cloud environment. Other factors may help distinguish between relevant and irrelevant NFs during the discovery process performed by discovery engine 112.

An illustrative discovery and filtering process may begin with discovery engine 112 querying a set of configurable and pre-determined resources from the cloud environment (e.g., master cloud environment 102) to generate a list of meaningful/relevant resources for the purpose of mapping the resources to the NRM model (e.g., block 2A). Resources returned by the cloud environment may be evaluated against configurable and pre-determined discovery rules (e.g., corresponding with TopologyMapper CRD) (e.g., block 2B). These rules may identify the NRM model that the cloud resource is part of. For representing this natively at the cloud environment, a new CR instance of the NF may be created if it does not already exist.

The CRD may represent the NRM model as custom cloud resource so that resources may exist within the master cloud environment 102 as a first class citizen. In being a first class citizen, the resources may support operations generally available to other entities, including implementing operations being passed as an argument, returned from a function, modified, and/or assigned to a variable.

The discovery process implemented by discovery engine 112 may not rely on a pre-existing template that lists the NFs that are previously implemented, but rather automatically and dynamically identify the NFs in the cloud environment using the rule-based process described herein. In the template implementation, an administrative user may manually map the discovered VMs or other NFs to the template items, whereas the rule-based system may be implemented automatically and dynamically by relying on trigger messages or hooks that are implemented for other purposes (e.g., to initiate a network function, to provide a service to a user, or other functions) to identify changes to the system and automate the mapping changes to master cloud environment 102.

As part of the discovery process implemented by discovery engine 112, the discovery and mapping micro-service may watch for resource changes to the cloud environment using “hooks” & receive trigger messages upon updates. Hooks may comprise one or more machine readable instructions that enable containers to be aware of events in the cloud environment by locally implementing a trigger function at the container 126 that detects changes and other events happening at the container 126. The events may correspond with a management lifecycle of the container 126 (e.g., once the container is created or immediately after the container is terminated). Once the event is activated, the container 126 may execute the machine readable instructions that are implemented in a handler when the corresponding lifecycle hook is executed.

In an illustrative example, when a container lifecycle management hook is called, the master cloud environment 102 (via controller 106) executes the handler according to the hook action. The node 122 (via kubelet 130) may schedule or execute one or more machine readable instructions, for example, “httpGet” and “tcpSocket” in order to probe the status of container 126, or may execute an “exec” machine readable instruction to execute a specified command in the container 126 (e.g., to check if a file exists).

Trigger messages may contain a status of container 126 in response to the kubelet 130 instructions, which can be sent as one or more electronic messages. The trigger messages may be posted has webhooks by API 120 (e.g., using the HTTP POST command) at the container 126 level. In some cloud environments, multiple kinds of hooks can exist for receiving different actions, including a create hook, update hook, or delete hook. One or more attributes of the affected resource may be sent to the respective hook in order to act as the trigger message.

Once the trigger message is received by discovery engine 112, the trigger message may be analyzed to determine a corresponding resource and resource attributes using the stored or predetermined rules (e.g., block 2B). For example, the rules may first identify the NF type (using attributes present in the message) to identify which resource the NF belongs to (e.g., filtering). Then, the rules can determine the name and other attributes of the NF that the cloud resource belongs to, using the attribute values (e.g., mapping). The identified rule may be evaluated against cloud resources and an NRM model may be constructed where rules identify the NF that the resource is a part of.

In some examples, discovery engine 112 may also register the discovery and mapping micro-service. For example, discovery engine 112 may register discovery and mapping micro-service via API server 120 using a flag or other data object. Once discovery and mapping micro-service is registered, the micro-service (via controller 106) may detect changes to the known set of resources in master cloud environment 102. When any change is identified, the discovery and mapping micro-service rules may be evaluated again and NF resource inventory may be updated at ETCD server 108. This may help to avoid running costly periodic resource reconciliation processing.

Discovery engine 112 may also create a custom resource in master cloud environment 102 and one or more new rules can be added by creating a new instance. The rules for discovery may be generated based on knowledge of the NF composition using the NRM model. When the discovery and mapping micro-service runs, the rules implemented by discovery engine 112 may create a custom resource instance or custom NF instance that maintains the defined relationship between the NF and cloud resource (e.g., for tracking purposes). In some examples, the cloud resources managed by master cloud environment 102 may also have implicit relationships between themselves and, when combined together, may create a complete hierarchical relationship. As an illustrative example, master cloud environment 102 may be related to the Namespace, which may be related to the AUSFFunction (NRM), which may be related to the nausf-auth (NRM) deployment, which may be related to the ReplicaSet, which may be related to one or more pods 124, which may be related to one or more containers 126.

Various rules may include a Boolean condition, an expression condition, or a prefix and suffix expression. The Boolean condition may comprise labels and attributes of the cloud resource to determine if the resource belongs to the NF or not. The expression condition may first evaluate whether the Boolean condition is true. If so, the expression condition may perform a second evaluation that comprises labels and attributes of the cloud resource that results in NF instance name. The prefix and suffix expressions may comprise labels and attributes of the cloud resource to determine the complete instance name of the NF.

Once the resources are identified, computing device 110 can generate a model of the cloud environment using modeling engine 114 at block 3 of FIG. 2 . Various modeling formats may be implemented without diverting from the essence of the disclosure. For example, modeling engine 114 may generate a model of the cloud environment that corresponds with the NFs and node(s) 122 that implement each NF through a reconciliation.

Reconciliation may comprise keeping discovered inventory up-to-date with any changes occurring within the cloud environment and depicting relationships between the NFs and resources. For example, at start up or after reconnection with master cloud environment 102, the discovery engine 112 of computing device 110 may rediscover one or more resources and reevaluate the discovery and mapping micro-service rules associated with them. The NRM model may be reconstructed again (e.g., if any changes are identified or may be automatically reconstructed without a comparison between versions of the NRM model), which may reperform the discovery process from scratch. This may prevent a mis-synchronization of inventory.

In some examples, the reconciliation may comprise realigning existing inventory. For example, controller 106 may initiate a reconciliation loop that reads the desired state of a resource from API server 120 and takes action to bring the cluster's actual state closer to the desired state. In some examples, each reconciliation loop may activate a hook or trigger message that causes the map to be redrawn.

In some examples, the reconciliation may comprise updating existing inventory or other data stored with ETCD server 108. For example, since the NRM model is represented as a user-defined custom resource (CRD), any update to it may result in updates to ETCD server 108 to help maintain an accurate inventory of cluster data (e.g., API data, configuration data, or other inventory data).

In some examples, the discovery and mapping micro-service may create a figurative bridge between two environments. In other words, the discovery and mapping micro-service can help make a data-driven or illustrative connection between cloud resources using the NRM model, including the example provided with FIG. 3 .

FIG. 3 illustrates a model of a cloud environment, which may be generated by modeling engine 114. As illustrated in FIG. 3 , the model may be represented using a custom cloud resource instance or other micro-service running within the cloud environment. Using the model, the NF's composition is mapped between NFs and virtual or physical machines with a complete inventory view and no external system or prior knowledge of deployed NFs or NRM model may be required.

The links or lines illustrated in FIG. 3 may represent a relationship between the components (e.g., a hosting relationship), one object being composed of another object, one object associated with another object in a communicative relationship, or other object communications. These and other relationships may be discovered and mapped using the discovery and mapping micro-service discussed throughout the disclosure.

At block 310, a cloud environment is illustrated, which may correspond with master cloud environment 102 in FIG. 1 .

At block 312, “ausf-nf-top” is an example component (Namespace) within cluster that is hosting NF via Authentication Server Function (AUSF).

At block 314, “3gpp-ausf-function” is an example custom resource that is newly discovered using the discovery and mapping micro-service. It may represent the AUSF network function that is not discoverable using the standard 3GPP model and objects provided natively by master cloud environment 102 illustrated in FIG. 1 .

At blocks 320 (illustrated as a plurality of deployed resources by master cloud environment 102 illustrated in FIG. 1 , including first resource 320A, second resource 320B, third resource 320C, fourth resource 320D, fifth resource 320E, sixth resource 320F), “hpe-nf-ausf” are examples of a plurality of deployed resources. These deployed resources may be provided natively by master cloud environment 102 illustrated in FIG. 1 as a deployment>ReplicaSet>pod resources.

At blocks 322 (illustrated as a plurality of containers 126 of one or more respective pods 124 illustrated in FIG. 1 , including first container 322A and second container 322B), “Nausf-auth” and “nausf-authre” are a plurality of example containers.

At blocks 324 (illustrated as a plurality of other components (Namespaces) outside of the cluster that is hosting NF via AUSF, including first Namespace 324A and second Namespace 324B), “5gnf” and “new5Gnf” are a plurality of example Namespaces.

FIG. 4 illustrates an example computing component that may be used to implement discovery and mapping of micro-services in a cloud environment, in accordance with various embodiments. For example, computing component 400 may be, for example, a server computer, a controller, or any other similar computing component capable of processing data, including computing device 110 illustrated in FIG. 1 . In the example implementation of FIG. 4 , the computing component 400 includes a hardware processor 402 and machine-readable storage medium for 404.

Hardware processor 402 may be one or more central processing units (CPUs), semiconductor-based microprocessors, and/or other hardware devices suitable for retrieval and execution of instructions stored in machine-readable storage medium 404. Hardware processor 402 may fetch, decode, and execute instructions, such as instructions 406-410, to control processes or operations for dynamically discovering and mapping a cloud environment. As an alternative or in addition to retrieving and executing instructions, hardware processor 402 may include one or more electronic circuits that include electronic components for performing the functionality of one or more instructions, such as a field programmable gate array (FPGA), application specific integrated circuit (ASIC), or other electronic circuits.

A machine-readable storage medium, such as machine-readable storage medium 404, may be any electronic, magnetic, optical, or other physical storage device that contains or stores executable instructions. Thus, machine-readable storage medium 404 may be, for example, Random Access Memory (RAM), non-volatile RAM (NVRAM), an Electrically Erasable Programmable Read-Only Memory (EEPROM), a storage device, an optical disc, and the like. In some embodiments, machine-readable storage medium 404 may be a non-transitory storage medium, where the term “non-transitory” does not encompass transitory propagating signals. As described in detail below, machine-readable storage medium 404 may be encoded with executable instructions, for example, instructions 406-410.

Hardware processor 402 may execute one or more instructions to discover and map one or more micro-services implemented in master cloud environment 102. For example, computing device 110 may access a command line tool for interacting with ETCD server 108 using a network topology mapping function (e.g., TopologyMapper), AUSF, UDM function, or other processes described herein (e.g., a user-defined custom resource, filtering/removing stateless functions, or other processes) using discovery engine 112. Depending on the function implemented, computing device 110 may discover the NFs or other resources implemented in master cloud environment 102.

In some examples, the discovery process implemented by discovery engine 112 may also watch for resource changes to master cloud environment 102. The resource changes may be identified using, for example, hooks, events, or other trigger messages upon updates.

Hardware processor 402 may execute instruction 406 to initialize a discovery and mapping micro-service in a cloud environment configured to generate a map layout of the cloud environment. In some examples, the map layout can correlate one or more application components to a deployed resource in master cloud environment 102.

In some examples, the discovery and mapping micro-service receives a hook or trigger message implemented with a container in the cloud environment, wherein the hook or trigger message is activated in response to an event (e.g., a resource change). The discovery and mapping micro-service may evaluate the event for involving a resource change to the deployed resource in master cloud environment 102.

Hardware processor 402 may execute instruction 408 to determine, using the discovery and mapping micro-service, that the resource change involves the deployed resource in master cloud environment 102. For example, the trigger message generated from the hook action may contain a status of container 126 in response to the kubelet 130 instructions. The trigger message can be posted has webhooks by API 120 (e.g., using the HTTP POST command) at the container 126 level. In some examples, the trigger message comprises a corresponding resource and resource attributes that can be evaluated against the predetermined rules. The evaluation may first identify the NF type (using attributes present in the message) to identify which resource the NF belongs to (e.g., filtering). Then, the rules can determine the name and other attributes of the NF using the attribute values (e.g., mapping).

Hardware processor 402 may execute instruction 410 to realign or update the map layout. For example, responsive to an electronic message received from master cloud environment 102 associated with the resource change the realignment or update to the map layout may be initiated (e.g., based on a new hook or other trigger message received from master cloud environment 102).

FIG. 5 depicts a block diagram of an example computer system 500 in which various of the embodiments described herein may be implemented. The computer system 500 includes a bus 502 or other communication mechanism for communicating information, one or more hardware processors 504 coupled with bus 502 for processing information. Hardware processor(s) 504 may be, for example, one or more general purpose microprocessors.

The computer system 500 also includes a main memory 506, such as a random access memory (RAM), cache and/or other dynamic storage devices, coupled to bus 502 for storing information and instructions to be executed by processor 504. Main memory 506 also may be used for storing temporary variables or other intermediate information during execution of instructions to be executed by processor 504. Such instructions, when stored in storage media accessible to processor 504, render computer system 500 into a special-purpose machine that is customized to perform the operations specified in the instructions.

The computer system 500 further includes a read only memory (ROM) 508 or other static storage device coupled to bus 502 for storing static information and instructions for processor 504. A storage device 510, such as a magnetic disk, optical disk, or USB thumb drive (Flash drive), etc., is provided and coupled to bus 502 for storing information and instructions.

The computer system 500 may be coupled via bus 502 to a display 512, such as a liquid crystal display (LCD) (or touch screen), for displaying information to a computer user. An input device 514, including alphanumeric and other keys, is coupled to bus 502 for communicating information and command selections to processor 504. Another type of user input device is cursor control 516, such as a mouse, a trackball, or cursor direction keys for communicating direction information and command selections to processor 504 and for controlling cursor movement on display 512. In some embodiments, the same direction information and command selections as cursor control may be implemented via receiving touches on a touch screen without a cursor.

The computing system 500 may include a user interface module to implement a GUI that may be stored in a mass storage device as executable software codes that are executed by the computing device(s). This and other modules may include, by way of example, components, such as software components, object-oriented software components, class components and task components, processes, functions, attributes, procedures, subroutines, segments of program code, drivers, firmware, microcode, circuitry, data, databases, data structures, tables, arrays, and variables.

In general, the word “component,” “engine,” “system,” “database,” data store,” and the like, as used herein, can refer to logic embodied in hardware or firmware, or to a collection of software instructions, possibly having entry and exit points, written in a programming language, such as, for example, Java, C or C++. A software component may be compiled and linked into an executable program, installed in a dynamic link library, or may be written in an interpreted programming language such as, for example, BASIC, Perl, or Python. It will be appreciated that software components may be callable from other components or from themselves, and/or may be invoked in response to detected events or interrupts. Software components configured for execution on computing devices may be provided on a computer readable medium, such as a compact disc, digital video disc, flash drive, magnetic disc, or any other tangible medium, or as a digital download (and may be originally stored in a compressed or installable format that requires installation, decompression or decryption prior to execution). Such software code may be stored, partially or fully, on a memory device of the executing computing device, for execution by the computing device. Software instructions may be embedded in firmware, such as an EPROM. It will be further appreciated that hardware components may be comprised of connected logic units, such as gates and flip-flops, and/or may be comprised of programmable units, such as programmable gate arrays or processors.

The computer system 500 may implement the techniques described herein using customized hard-wired logic, one or more ASICs or FPGAs, firmware and/or program logic which in combination with the computer system causes or programs computer system 500 to be a special-purpose machine. According to one embodiment, the techniques herein are performed by computer system 500 in response to processor(s) 504 executing one or more sequences of one or more instructions contained in main memory 506. Such instructions may be read into main memory 506 from another storage medium, such as storage device 510. Execution of the sequences of instructions contained in main memory 506 causes processor(s) 504 to perform the process steps described herein. In alternative embodiments, hard-wired circuitry may be used in place of or in combination with software instructions.

The term “non-transitory media,” and similar terms, as used herein refers to any media that store data and/or instructions that cause a machine to operate in a specific fashion. Such non-transitory media may comprise non-volatile media and/or volatile media. Non-volatile media includes, for example, optical or magnetic disks, such as storage device 510. Volatile media includes dynamic memory, such as main memory 506. Common forms of non-transitory media include, for example, a floppy disk, a flexible disk, hard disk, solid state drive, magnetic tape, or any other magnetic data storage medium, a CD-ROM, any other optical data storage medium, any physical medium with patterns of holes, a RAM, a PROM, and EPROM, a FLASH-EPROM, NVRAM, any other memory chip or cartridge, and networked versions of the same.

Non-transitory media is distinct from but may be used in conjunction with transmission media. Transmission media participates in transferring information between non-transitory media. For example, transmission media includes coaxial cables, copper wire and fiber optics, including the wires that comprise bus 502. Transmission media can also take the form of acoustic or light waves, such as those generated during radio-wave and infra-red data communications.

The computer system 500 also includes a communication interface 518 coupled to bus 502. Communication interface 518 provides a two-way data communication coupling to one or more network links that are connected to one or more local networks. For example, communication interface 518 may be an integrated services digital network (ISDN) card, cable modem, satellite modem, or a modem to provide a data communication connection to a corresponding type of telephone line. As another example, communication interface 518 may be a local area network (LAN) card to provide a data communication connection to a compatible LAN (or WAN component to communicated with a WAN). Wireless links may also be implemented. In any such implementation, communication interface 518 sends and receives electrical, electromagnetic or optical signals that carry digital data streams representing various types of information.

A network link typically provides data communication through one or more networks to other data devices. For example, a network link may provide a connection through local network to a host computer or to data equipment operated by an Internet Service Provider (ISP). The ISP in turn provides data communication services through the world wide packet data communication network now commonly referred to as the “Internet.” Local network and Internet both use electrical, electromagnetic or optical signals that carry digital data streams. The signals through the various networks and the signals on network link and through communication interface 518, which carry the digital data to and from computer system 500, are example forms of transmission media.

The computer system 500 can send messages and receive data, including program code, through the network(s), network link and communication interface 518. In the Internet example, a server might transmit a requested code for an application program through the Internet, the ISP, the local network and the communication interface 518.

The received code may be executed by processor 504 as it is received, and/or stored in storage device 510, or other non-volatile storage for later execution.

It should be noted that the terms “optimize,” “optimal” and the like as used herein can be used to mean making or achieving performance as effective or perfect as possible. However, as one of ordinary skill in the art reading this document will recognize, perfection cannot always be achieved. Accordingly, these terms can also encompass making or achieving performance as good or effective as possible or practical under the given circumstances, or making or achieving performance better than that which can be achieved with other settings or parameters.

Each of the processes, methods, and algorithms described in the preceding sections may be embodied in, and fully or partially automated by, code components executed by one or more computer systems or computer processors comprising computer hardware. The one or more computer systems or computer processors may also operate to support performance of the relevant operations in a “cloud computing” environment or as a “software as a service” (SaaS). The processes and algorithms may be implemented partially or wholly in application-specific circuitry. The various features and processes described above may be used independently of one another, or may be combined in various ways. Different combinations and sub-combinations are intended to fall within the scope of this disclosure, and certain method or process blocks may be omitted in some implementations. The methods and processes described herein are also not limited to any particular sequence, and the blocks or states relating thereto can be performed in other sequences that are appropriate, or may be performed in parallel, or in some other manner. Blocks or states may be added to or removed from the disclosed example embodiments. The performance of certain of the operations or processes may be distributed among computer systems or computers processors, not only residing within a single machine, but deployed across a number of machines.

As used herein, a circuit might be implemented utilizing any form of hardware, software, or a combination thereof. For example, one or more processors, controllers, ASICs, PLAs, PALs, CPLDs, FPGAs, logical components, software routines or other mechanisms might be implemented to make up a circuit. In implementation, the various circuits described herein might be implemented as discrete circuits or the functions and features described can be shared in part or in total among one or more circuits. Even though various features or elements of functionality may be individually described or claimed as separate circuits, these features and functionality can be shared among one or more common circuits, and such description shall not require or imply that separate circuits are required to implement such features or functionality. Where a circuit is implemented in whole or in part using software, such software can be implemented to operate with a computing or processing system capable of carrying out the functionality described with respect thereto, such as computer system 500.

As used herein, the term “or” may be construed in either an inclusive or exclusive sense. Moreover, the description of resources, operations, or structures in the singular shall not be read to exclude the plural. Conditional language, such as, among others, “can,” “could,” “might,” or “may,” unless specifically stated otherwise, or otherwise understood within the context as used, is generally intended to convey that certain embodiments include, while other embodiments do not include, certain features, elements and/or steps.

Terms and phrases used in this document, and variations thereof, unless otherwise expressly stated, should be construed as open ended as opposed to limiting. Adjectives such as “conventional,” “traditional,” “normal,” “standard,” “known,” and terms of similar meaning should not be construed as limiting the item described to a given time period or to an item available as of a given time, but instead should be read to encompass conventional, traditional, normal, or standard technologies that may be available or known now or at any time in the future. The presence of broadening words and phrases such as “one or more,” “at least,” “but not limited to” or other like phrases in some instances shall not be read to mean that the narrower case is intended or required in instances where such broadening phrases may be absent. 

What is claimed is:
 1. A computing device comprising: a memory; and one or more processors that are configured to execute machine readable instructions stored in the memory to: initialize, by the computing device, a discovery and mapping micro-service in a cloud environment, wherein the discovery and mapping micro-service is configured to generate a map layout of the cloud environment, wherein the map layout correlates one or more application components to a deployed resource in the cloud environment, and wherein the discovery and mapping micro-service is to: receive a locally-implemented trigger message implemented by at least one container in the cloud environment, wherein the locally-implemented trigger message is implemented by the at least one container in the cloud environment and received by the computing device, wherein the trigger message is activated in response to an event happening at the at least one container in the cloud environment to affect a deployed resource in the cloud environment, and wherein the trigger message identifies an attribute of the deployed resource, and evaluate, by the computing device, the trigger message to identify the deployed resource in the cloud environment as being affected by the event; determine, using the discovery and mapping micro-service, that the event involves a resource change to the deployed resource in the cloud environment; and responsive to an electronic message received from the cloud environment associated with the resource change, realign or update the map layout by the computing device, and wherein the method further comprises: determining that the resource change to the deployed resource causes the deployed resource to not be aligned with a standard Network Resource Model (NRM); and based on not being aligned with the standard NRM, removing the electronic message received from the cloud environment associated with the resource change.
 2. The computing device of claim 1, wherein the initializing of the discovery and mapping micro-service is performed automatically.
 3. The computing device of claim 1, wherein the discovery and mapping micro-service is initialized in addition to one or more micro-services implemented to perform network functions that is separated into the one or more application components.
 4. The computing device of claim 1, wherein the discovery and mapping micro-service dynamically discovers and maps the cloud environment.
 5. The computing device of claim 1, wherein the trigger message is a hook that is locally implemented in the cloud environment.
 6. The computing device of claim 1, wherein the trigger message is matched with stored rules to detect changes of the cloud environment.
 7. The method of claim 1, wherein the resource change is not being aligned with the standard NRM model as the deployed resource involves a stateless Network Function (NF).
 8. A computer-implemented method comprising: initializing, by a computing device, a discovery and mapping micro-service in a cloud environment, wherein the discovery and mapping micro-service is configured to generate a map layout of the cloud environment, wherein the map layout correlates one or more application components to a deployed resource in the cloud environment, and wherein the discovery and mapping micro-service is to: receive a locally-implemented trigger message implemented by at least one container in the cloud environment, wherein the locally-implemented trigger message is implemented by the at least one container in the cloud environment and received by the computing device, wherein the trigger message is activated in response to an event happening at the at least one container in the cloud environment to affect a deployed resource in the cloud environment, and wherein the trigger message identifies an attribute of the deployed resource, and evaluate, by the computing device, the trigger message to identify the deployed resource in the cloud environment as being affected by the event; determining, using the discovery and mapping micro-service, that the event involves a resource change to the deployed resource in the cloud environment; and responsive to an electronic message received from the cloud environment associated with the resource change, realigning or updating the map layout by the computing device, and further comprising: determining that the resource change to the deployed resource causes the deployed resource to not be aligned with a standard Network Resource Model (NRM); and based on not being aligned with the standard NRM, removing the electronic message received from the cloud environment associated with the resource change.
 9. The method of claim 8, wherein the initializing of the discovery and mapping micro-service is performed automatically.
 10. The method of claim 8, wherein the discovery and mapping micro-service is initialized in addition to one or more micro-services implemented to perform network functions that is separated into the one or more application components.
 11. The method of claim 8, wherein the discovery and mapping micro-service dynamically discovers and maps the cloud environment.
 12. The method of claim 8, wherein the trigger message is a hook that is locally implemented in the cloud environment.
 13. The method of claim 8, wherein the trigger message is matched with stored rules to detect changes of the cloud environment.
 14. The method of claim 8, wherein the resource change is not being aligned with the standard NRM model as the deployed resource involves a stateless Network Function (NF).
 15. A non-transitory computer-readable storage medium storing a plurality of instructions executable by one or more processors, the plurality of instructions when executed by the one or more processors cause the one or more processors to: initialize a discovery and mapping micro-service in a cloud environment, wherein the discovery and mapping micro-service is configured to generate a map layout of the cloud environment, wherein the map layout correlates one or more application components to a deployed resource in the cloud environment, and wherein the discovery and mapping microservice is to: receive a locally-implemented trigger message implemented by at least one container in the cloud environment, wherein the locally-implemented trigger message is implemented by the at least one container in the cloud environment, wherein the trigger message is activated in response to an event happening at the at least one container in the cloud environment to affect a deployed resource in the cloud environment, and wherein the trigger message identifies an attribute of the deployed resource, and evaluate the trigger message to identify the deployed resource in the cloud environment as being affected by the event; determine, using the discovery and mapping micro-service, that the event involves a resource change to the deployed resource in the cloud environment; and responsive to an electronic message received from the cloud environment associated with the resource change, realign or update the map layout, and further comprising: determining that the resource change to the deployed resource causes the deployed resource to not be aligned with a standard Network Resource Model (NRM); and based on not being aligned with the standard NRM, removing the electronic message received from the cloud environment associated with the resource change.
 16. The non-transitory computer-readable storage medium of claim 15, wherein the initializing of the discovery and mapping micro-service is performed automatically.
 17. The non-transitory computer-readable storage medium of claim 15, wherein the discovery and mapping micro-service is initialized in addition to one or more micro-services implemented to perform network functions that is separated into the one or more application components.
 18. The non-transitory computer-readable storage medium of claim 15, wherein the discovery and mapping micro-service dynamically discovers and maps the cloud environment. 